#-*- coding: UTF-8 -*-
from pyramid.httpexceptions import HTTPFound
from pyramid.security import remember
from pyramid.security import forget

from sqlalchemy.orm import eagerload


from scp.modelo.models import DBSession
from scp.modelo.Usuario import Usuario
from scp.modelo.Rol import Rol
from scp.modelo.Permiso import Permiso
from scp.modelo.Fase import Fase
from scp.modelo.Proyecto import Proyecto
from scp.modelo.Recurso import Recurso
from scp.modelo.AsignacionRecurso import AsignacionRecurso

from pyramid.response import Response
from pyramid.view import view_config
import json

import re
from sqlalchemy import and_

#@view_config(renderer='json')
def roles(request):
	"""Método controlador encargado de la administración de los Roles.
		URL asociada: /roles/{operacion}
		operacion:
			view, listado de roles
			create, creación de un nuevo rol
			update, edición de un rol
			destroy, elminiación de rol
		@param request: Petición Http del cliente. 	
	"""


	print ">>>>>>>>>>>>>Controlador de Roles - Inicio>>>>>>>>>>>>>>"
	print "request:"
	print request

	print 'metodo:'
	
	methodRequest = request.method
	print methodRequest
	
	print 'request.url:'
	
	print request.url
	
	
	dicParametros = request.matchdict
	
		
	print "parametros abajo..."
	print request.params
	
	print 'request.body'
	print request.body 
	

	print "operación"
	print dicParametros.get('operacion')
	print "operación"
	
	
	if dicParametros.get('operacion') == 'update' or dicParametros.get('operacion') == 'create':
		
		
		print 'json.loads(request.params[rol])'
		rol = json.loads(request.params['rol'])
		print json.loads(request.params['rol'])
		print 'rol.data'
		rolData = rol.get('data')
		print rol.get('data')
		print 'rol.data.nombreRol'
		print rolData.get('nombreRol')
		print 'json.loads(request.params[ids_permisos])'
		permisos = json.loads(request.params['ids_permisos'])
		print permisos
	
	print 'dicParametros.get(operacion).find(?):' 
	print dicParametros.get('operacion').find('?')
	
	session = DBSession()
	if dicParametros.get('operacion') == 'view' and request.url.find('?') == -1:
		print 'respondí un diccionario normal'
		return {'content':'Hello!'}	
	elif dicParametros.get('operacion') == 'view':
		rolesAll = session.query(Rol).all()
		
		print '>>rolesAll'
		print rolesAll
		
		rolesArray = []
		for rolIter in rolesAll:
			aux = {'idRol': rolIter.id, 'nombreRol': rolIter.nombre, 'descripRol':rolIter.descripcion}
			rolesArray.append(aux)
		
		print '>>rolesArray'
		print rolesArray
			
		responseView = Response()
		#responseView.body = json.dumps(dict(success = True, roles = [{'idRol':'1', 'nombreRol': 'hola', 'descripRol':'mundo'}, {'idRol':'2', 'nombreRol': 'chau', 'descripRol':'mundo'}]))
		responseView.body = json.dumps(dict(success = True, roles = rolesArray))
		responseView.content_type = 'application/json'
		print 'respondí con un Responseeeee!!!'
		return responseView
	elif dicParametros.get('operacion') == 'create':
		
		rolExiste = session.query(Rol).filter_by(nombre=rolData.get('nombreRol')).first()
		
		if rolExiste == None:
			rol = Rol()
			rol.nombre = rolData.get('nombreRol')
			rol.descripcion = rolData.get('descripRol')
			
			permisosArray = []
			
			for idPermiso in permisos:
				permiso = session.query(Permiso).filter_by(id=idPermiso).first()
				permisosArray.append(permiso)
			
					
			rol.permisos =  permisosArray
			session.add(rol)	
		
			responseCreate = Response()
			responseCreate.body = json.dumps(dict(success = True, rsp='ok', msg = 'Rol Creado Exitosamente!'))
			responseCreate.content_type = 'application/json'
		else:
			
			responseCreate = Response()
			responseCreate.body = json.dumps(dict(success = True, rsp='er', msg = 'Rol ya existe!'))
			responseCreate.content_type = 'application/json'	
		
		return responseCreate	
	
	
	elif dicParametros.get('operacion') == 'update':
		#rolEditar = session.query(Rol).filter_by(id=rolData.get('idRol')).first()
		rolEditar = session.query(Rol).options(eagerload('permisos')).filter_by(id=rolData.get('idRol')).one() 
		#permisosNoAnda = session.query(Rol.permisos).filter_by(id=rolData.get('idRol')).all()
		
		print '>>>rolEditar'
		print rolEditar
		
		print '>>>rolEditar.permisos'
		print rolEditar.permisos
		
		
		print '>>>rolEditar.nombre'
		print rolEditar.nombre
		
		#print 'permisosNoAnda'
		#print permisosNoAnda
		
		rolExiste = session.query(Rol).filter( and_(Rol.nombre==rolData.get('nombreRol'), Rol.id != rolData.get('idRol'))).first()
		
		if rolExiste is None:
			rolEditar.nombre = rolData.get('nombreRol')
		
			print '>>>rolData.get(descripRol)'
			print rolData.get('descripRol')
			
			rolEditar.descripcion = rolData.get('descripRol')
			
			idsPermisosEditar = json.loads(request.params['ids_permisos'])
			
			print '>>>idsPermisosEditar'
			print idsPermisosEditar
			
			permisosArray = []
			
			for idPermiso in idsPermisosEditar:
				print '>>idPermiso en el ciclo!!'
				print idPermiso
				permiso = session.query(Permiso).filter_by(id=idPermiso).first()
				permisosArray.append(permiso)
			
			
			
			rolEditar.permisos = permisosArray
			
			responseUpdate = Response()
			responseUpdate.body = json.dumps(dict(success = True, rsp='ok', msg = 'Rol Editado Exitosamente!'))
		else:
			responseUpdate = Response()
			responseUpdate.body = json.dumps(dict(success = True, rsp='er', msg = 'Rol ya existe!'))
		
		
		responseUpdate.content_type = 'application/json'
		return responseUpdate	
	elif dicParametros.get('operacion') == 'destroy':
		print 'entre en el if de update'
		
		idRolEliminar = json.loads(request.params['param_idRol'])
		rolEliminar = session.query(Rol).filter_by(id=idRolEliminar).first()
		
		"""usuarios = session.query(Usuario).all()
		rolUsado = False
		for usuario in usuarios:
			rolesUsuario = usuario.roles
			for rol in rolesUsuario:
				if rol.id == rolEliminar.id:
					rolUsado = True
					break
			if rolUsado:
				break
		"""
		asigRecursoRol = session.query(AsignacionRecurso).filter_by(rol_id=idRolEliminar).first()
		
		if asigRecursoRol == None :
			session.delete(rolEliminar)
			responseDestroy = Response()
			responseDestroy.body = json.dumps(dict(success = True, rsp='ok', msg = 'Eliminación Exitosa!'))
			responseDestroy.content_type = 'application/json'
		else:
			responseDestroy = Response()
			responseDestroy.body = json.dumps(dict(success = True, rsp='er', msg = 'Actualmente el Rol se encuentra en uso.!'))
			responseDestroy.content_type = 'application/json'
			
		return responseDestroy	
		
	elif dicParametros.get('operacion') == 'traerRolesDeMiembro':
		
		idMiembro =  json.loads(request.params['id'])
		proyectoID = json.loads(request.params['idProyecto'])
		
		print ('>>>>>>>>>>el ID del MIEMBRO es:')
		print idMiembro
		
		print ('>>>>>el ID PROYECTO es:')
		print proyectoID
		
		fasesAll = session.query(Fase).filter_by(proyecto_id=proyectoID).all()
		
		idsFases = []
		for iter in fasesAll:
			aux = iter.id
			idsFases.append(aux)
			
		recursosAll = session.query(Recurso).filter(Recurso.fase_id.in_(idsFases)).all()
		
		idsRecursos = []
		for iter1 in recursosAll:
			aux1 = iter1.id
			idsRecursos.append(aux1)
			
		asignacionRecAll = session.query(AsignacionRecurso).filter(AsignacionRecurso.recurso_id.in_(idsRecursos)).filter(AsignacionRecurso.usuario_id==idMiembro).all()
		num = 0
		rolesArray = []
		for iter in asignacionRecAll:
			num = num + 1
			
			rolIter = session.query(Rol).filter_by(id=iter.rol_id).first()
			aux = {'idRol': rolIter.id, 'nombreRol': rolIter.nombre, 'descripRol':rolIter.descripcion}
			if not (aux in rolesArray):
				print ('>>>>>>>>>el numero num es: y el rol es:')
				print num
				print rolIter.nombre
				rolesArray.append(aux)
		
		responseRolesAsignado = Response()
		responseRolesAsignado.body = json.dumps(dict(success = True, roles = rolesArray))
		responseRolesAsignado.content_type = 'application/json'
		return responseRolesAsignado
		
	elif dicParametros.get('operacion') == 'viewRoles':
		idMiembro =  json.loads(request.params['id'])
		proyectoID =  json.loads(request.params['idProyecto'])
		
		fasesAll = session.query(Fase).filter_by(proyecto_id=proyectoID).all()
		
		idsFases = []
		
		for iter in fasesAll:
			aux = iter.id
			idsFases.append(aux)
			
		recursosAll = session.query(Recurso).filter(Recurso.fase_id.in_(idsFases)).all()
		
		idsRecursos = []
		for iter1 in recursosAll:
			aux1 = iter1.id
			idsRecursos.append(aux1)
		
		recurAsigMiem = session.query(AsignacionRecurso).filter(AsignacionRecurso.recurso_id.in_(idsRecursos)).filter(AsignacionRecurso.usuario_id==idMiembro).all()
		vecRoles = []
		for iter in recurAsigMiem:
			aux = iter.rol_id
			if not (aux in vecRoles):
				vecRoles.append(aux)
			
		
		roles = session.query(Rol).filter(~Rol.id.in_(vecRoles)).all()
		
		rolesArray = []
		for rolIter in roles:
			aux = {'idRol': rolIter.id, 'nombreRol': rolIter.nombre, 'descripRol':rolIter.descripcion}
			rolesArray.append(aux)
		
			
		responseRolesDisponibles = Response()
		responseRolesDisponibles.body = json.dumps(dict(success = True, roles = rolesArray))
		responseRolesDisponibles.content_type = 'application/json'
		return responseRolesDisponibles
		
	elif dicParametros.get('operacion') == 'guardarAsignacion':
		idProyecto = json.loads(request.params['idProyecto'])
		idUser = json.loads(request.params['idMiembro'])
		idRol = json.loads(request.params['idRol'])
		idsRecursos = json.loads(request.params['idsFases'])
		
		rol = session.query(Rol).filter_by(id=idRol).first()
		usuario = session.query(Usuario).filter_by(id=idUser).first()
		
		#agrego los roles asignados al miembro en la tabla intermedia usuario-roles
		"""rolesArray = []
		rolesArray = usuario.roles
		
		rolesArray.append(rol)
		
		usuario.roles = rolesArray"""
		recursoProyecto = session.query(Recurso).filter_by(proyecto_id=idProyecto).first()
		
		asigRecurProyec = AsignacionRecurso()
		asigRecurProyec.rol_id = rol.id
		asigRecurProyec.recurso_id = recursoProyecto.id
		asigRecurProyec.usuario_id = usuario.id
		session.add(asigRecurProyec)
		
		for iterRecursos in idsRecursos:
			recursoAsig = AsignacionRecurso()
			
			recurso = session.query(Recurso).filter_by(fase_id=iterRecursos).first()
			
			recursoAsig.rol_id = rol.id
			recursoAsig.recurso_id = recurso.id
			recursoAsig.usuario_id = usuario.id
			session.add(recursoAsig)
				
		responseMiembro = Response()
		responseMiembro.body = json.dumps(dict(success = True))
		responseMiembro.content_type = 'application/json'
		return responseMiembro 	

	elif dicParametros.get('operacion') == 'guardarEditarFasesDeRol':
		
		miembroID = json.loads(request.params['idMiembro'])
		rolID = json.loads(request.params['idRol'])
		idsFases = json.loads(request.params['idsFases'])
		proyecId = json.loads(request.params['idProyecto'])
		
		print 'los ids de miembro, rol, fases y proyecto son:'
		
		print miembroID
		print rolID
		print idsFases
		print proyecId
		# traemos todas las fases q tiene ese proyecto que no fueron elegidas
		fasesAll = session.query(Fase).filter(~Fase.id.in_(idsFases)).filter(Fase.proyecto_id==proyecId).all()
		fasesNoElegidas = []
		for iter in fasesAll:
			aux = iter.id
			fasesNoElegidas.append(aux)
			
		print '>>>>>>>>>>>>>>>>>>>>fases no elegiadas'
		print fasesNoElegidas
		
		# traemos todos los recursos donde las fases del proyecto este en recurso	
		recursosAll = session.query(Recurso).filter(Recurso.fase_id.in_(idsFases)).all()
		idsRecursos = []
		for iter1 in recursosAll:
			aux1 = iter1.id
			idsRecursos.append(aux1)
		
		print '>>>>>>>>>>>>>>>>>>>>todos los recursos nuevos q se asignaran'
		print idsRecursos	
		
			
			
		rol = session.query(Rol).filter_by(id=rolID).first()
		usuario = session.query(Usuario).filter_by(id=miembroID).first()	
			
		for recursoIter in idsRecursos:
			asignacionRecurso = session.query(AsignacionRecurso).filter_by(recurso_id=recursoIter, rol_id=rolID, usuario_id = miembroID).first()
			if asignacionRecurso == None:
				recursoAsig = AsignacionRecurso()
			
				recurso = session.query(Recurso).filter_by(id=recursoIter).first()
				
				recursoAsig.rol_id = rol.id
				recursoAsig.recurso_id = recurso.id
				recursoAsig.usuario_id = usuario.id
				session.add(recursoAsig)
				
		# traemos los recursos que no fueron elgidos y debemos eliminar de AsignacionRecurso	
		recursosNoElegidos = session.query(Recurso).filter(Recurso.fase_id.in_(fasesNoElegidas)).all()
		
		
		
		idsRecurNoElegidos = []
		for iter2 in recursosNoElegidos:
			aux2 = iter2.id
			idsRecurNoElegidos.append(aux2)
			
		print '>>>>>>>>>>>>>>>>>>>>todos los recursos NO ESTAN MAS ASIGNADOS'
		print idsRecurNoElegidos	
		
		for recurNoElegIter in idsRecurNoElegidos:
			asignacionRecurso = session.query(AsignacionRecurso).filter_by(recurso_id=recurNoElegIter, rol_id=rolID, usuario_id = miembroID).first()
			if asignacionRecurso != None:
				session.delete(asignacionRecurso)
	
		
		
		responseEditFasesRol = Response()
		responseEditFasesRol.body = json.dumps(dict(success = True, rsp='ok', msg = 'Edicion Exitosa!'))
		responseEditFasesRol.content_type = 'application/json'
		return responseEditFasesRol
		
		
		
		
	elif dicParametros.get('operacion') == 'eliminarRolDeMiembro':
		
		proyecId = json.loads(request.params['idProyecto'])
		miembroID = json.loads(request.params['id'])
		rolID = json.loads(request.params['idRol'])
		
		print ('los ids de proyecto, miembro y rol son:')
		print (proyecId)
		print (miembroID)
		print (rolID)
		rol = session.query(Rol).filter_by(id=rolID).first()
		usuario = session.query(Usuario).filter_by(id=miembroID).first()
		#rolesDeUsuario = usuario.roles
		#elimina de la tabla intermedia usuario-roles cuando se elimina un rol del miembro
		#rolesDeUsuario.remove(rol)
		
		fasesAll = session.query(Fase).filter_by(proyecto_id=proyecId).all()
		
		idsFases = []
		for iter in fasesAll:
			aux = iter.id
			idsFases.append(aux)
		print ('idsFases')
		print (idsFases)	
			
		recursosAll = session.query(Recurso).filter(Recurso.fase_id.in_(idsFases)).all()
		
		idsRecursos = []
		for iter1 in recursosAll:
			aux1 = iter1.id
			idsRecursos.append(aux1)
		print ('idsRecursos')
		print (idsRecursos)
		
		recurAsignadoAll = session.query(AsignacionRecurso).filter(AsignacionRecurso.recurso_id.in_(idsRecursos)).filter(AsignacionRecurso.rol_id == rolID).filter(AsignacionRecurso.usuario_id == miembroID).all()
		print ('recurAsignadoAll')
		print (recurAsignadoAll)
		
		print ('antes de entrar a hacer el delete')
		for iterRecurAsignado in recurAsignadoAll:
			print ('>>>>>>> estoy dentro del delete')
			asigRecurso = session.query(AsignacionRecurso).filter_by(id = iterRecurAsignado.id).first()
			session.delete(asigRecurso)
		
		print ('descpues de hacer el delete')
		
		recursoProyecto = session.query(Recurso).filter(Recurso.proyecto_id == proyecId).first()
		asigProyecto = session.query(AsignacionRecurso).filter(AsignacionRecurso.recurso_id == recursoProyecto.id).filter(AsignacionRecurso.rol_id == rolID).filter(AsignacionRecurso.usuario_id == miembroID).first()
		session.delete(asigProyecto)
		
		responseDestroyRol = Response()
		responseDestroyRol.body = json.dumps(dict(success = True, rsp='ok', msg = 'Eliminación Exitosa!'))
		responseDestroyRol.content_type = 'application/json'
		
		return responseDestroyRol
		
 
